home *** CD-ROM | disk | FTP | other *** search
/ NeXT Education Software Sampler 1992 Fall / NeXT Education Software Sampler 1992 Fall.iso / Programming / Source / HippoDraw / HippoDrawSrc1.1 / Hippo.subproj / HTuple.m < prev    next >
Encoding:
Text File  |  1992-04-25  |  4.0 KB  |  188 lines
  1.  /* HTuple.m    by Paul Kunz    December 1991
  2.  * Object used to store information on open Hippo Tuple and methods
  3.  * to archive it to NXTypedStream.
  4.  *
  5.  * $Id: HTuple.m,v 1.8 1992/04/13 20:43:55 pfkeb Rel $
  6.  *
  7.  * Copyright (C)  1991  The Board of Trustees of
  8.  * The Leland Stanford Junior University.  All Rights Reserved.
  9.  */ 
  10.  
  11. #import "HTuple.h"
  12.  
  13. #import <appkit/nextstd.h>
  14. #import "strings.h"
  15.  
  16. #define INDEX_VERSION 1
  17. #define CURRENT_VERSION INDEX_VERSION
  18.  
  19. @implementation HTuple
  20.  
  21. + initialize
  22. {
  23.     [self setVersion:CURRENT_VERSION];
  24.     return self;
  25. }
  26.  
  27. - initTuple:(ntuple) nt file:(const char *)path
  28.          by:(BOOL)refFlag mode:(BOOL) binFlag index:(int) iValue
  29. {
  30.     [super init];
  31.     tuple = nt;
  32.     isRef = refFlag;
  33.     isBinary = binFlag;
  34.     if ( filename == NULL ) {
  35.         NX_ZONEMALLOC( [self zone], filename, char, strlen(path)+1 );
  36.     } else {
  37.         NX_ZONEREALLOC( [self zone], filename, char, strlen(path)+1 );
  38.     }
  39.     strcpy( filename, path );
  40.     [self setFakeFilename:NO];
  41.     ntindex = iValue;
  42.     return self;
  43. }
  44. - (ntuple) ntuple
  45. {
  46.     return tuple;
  47. }
  48. - setNtuple:(ntuple) aTuple;
  49. {
  50.     tuple = aTuple;
  51.     return self;
  52. }
  53. - (BOOL) isRef
  54. {
  55.     return isRef;
  56. }
  57. - setIsRef:(BOOL) refFlag
  58. {
  59.     isRef = refFlag;
  60.     return self;
  61. }
  62. - setIsBinary:(BOOL) binFlag
  63. {
  64.     isBinary = binFlag;
  65.     return self;
  66. }
  67. - (const char *)filename
  68. {
  69.     return filename;
  70. }
  71. - setFilename:(const char *)path
  72. {
  73.     if ( filename == NULL ) {
  74.         NX_ZONEMALLOC( [self zone], filename, char, strlen(path)+1 );
  75.     } else {
  76.         NX_ZONEREALLOC( [self zone], filename, char, strlen(path)+1 );
  77.     }
  78.     strcpy( filename, path );
  79.     return self;
  80. }
  81. - (int) index
  82. {
  83.     return ntindex;
  84. }
  85. - setIndex:(int) value
  86. {
  87.     ntindex = value;
  88.     return self;
  89. }
  90. - setAltFilename:(const char *)path
  91. {
  92.     if ( altfilename == NULL ) {
  93.         NX_ZONEMALLOC( [self zone], altfilename, char, strlen(path)+1 );
  94.     } else {
  95.         NX_ZONEREALLOC( [self zone], altfilename, char, strlen(path)+1 );
  96.     }
  97.     strcpy( altfilename, path );
  98.     return self;
  99. }
  100. - (const char *)altfilename
  101. {
  102.     return altfilename;
  103. }
  104. - (BOOL) isFakeFilename
  105. {
  106.     return fakeFilename;
  107. }
  108. - setFakeFilename:(BOOL) bValue
  109. {
  110.     fakeFilename = bValue;
  111.     return self;
  112. }
  113. - (BOOL) isSameAs:aTuple
  114. {
  115.     if ( strcmp( filename, [aTuple filename] ) ) {
  116.         return NO;
  117.     }
  118.     if ( [aTuple index] != ntindex ) {
  119.         return NO;
  120.     }
  121.     return YES;
  122. }
  123. - (const char *) title
  124. {
  125.     if ( tuple ) {
  126.        return h_getNtTitle( tuple );
  127.     } else {
  128.        return "not available";
  129.     }
  130. }
  131. - write:(NXTypedStream *) stream
  132. {
  133.     ntuple    ntlist[] = {NULL, NULL};
  134.     char    *buffer;
  135.     int        nt_size, len_fn;
  136.     
  137.     [super write:stream];
  138.     len_fn = strlen( filename );
  139.     NXWriteTypes( stream, "cci", &isRef, &isBinary, &len_fn );
  140.     NXWriteTypes( stream, "*", &filename );
  141.     if ( [HTuple version] >= INDEX_VERSION ) {
  142.         NXWriteTypes( stream, "i", &ntindex );
  143.     }
  144.     if ( !isRef ) {
  145.     nt_size = h_ntSize( tuple );
  146.         NX_ZONEMALLOC( [self zone], buffer, char, nt_size );
  147.     ntlist[0] = tuple;
  148.     h_writeMem( buffer, nt_size, NULL, ntlist );
  149.     NXWriteType( stream, "i", &nt_size );
  150.     NXWriteArray( stream, "c", nt_size, buffer );
  151.     NX_FREE(buffer);
  152.     }
  153.     return self;
  154. }
  155. - read:(NXTypedStream *) stream
  156. {
  157.     ntuple    *ntlist;
  158.     display    *dlist;
  159.     char    *buffer;
  160.     int        nt_size, len_fn;
  161.     
  162.     [super read:stream];
  163.     NXReadTypes( stream, "cci", &isRef, &isBinary, &len_fn );
  164.     NX_ZONEMALLOC( [self zone], filename, char, len_fn+1 );
  165.     NXReadTypes( stream, "*", &filename );
  166.     if ( NXTypedStreamClassVersion(stream, "HTuple") >= INDEX_VERSION ) {
  167.     NXReadType( stream, "i", &ntindex );
  168.     }
  169.     if ( !isRef ) {
  170.         NXReadType( stream, "i", &nt_size );
  171.         NX_ZONEMALLOC( [self zone], buffer, char, nt_size );
  172.     NXReadArray( stream, "c", nt_size, buffer );
  173.     h_readMem( buffer, nt_size, &dlist, &ntlist );
  174.     tuple = ntlist[0];
  175.     NX_FREE(buffer);
  176.     }
  177.     return self;
  178. }
  179. - free
  180. {
  181.     h_freeNt( tuple );
  182.     NXZoneFree([self zone], filename );
  183.     NXZoneFree([self zone], altfilename );
  184.     return [super free];
  185. }
  186.  
  187. @end
  188.